home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet multimedia / Animacje, filmy i prezentacje / Modelowanie 3D / K-3D 0.6.5.0 / k3d-all-in-one-setup-0.6.5.0.exe / aqsis-setup-1.1.0-2006-12-09.exe / include / aqsis / vector2d.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-06-14  |  6.7 KB  |  300 lines
  1. // Aqsis
  2. // Copyright ⌐ 1997 - 2001, Paul C. Gregory
  3. //
  4. // Contact: pgregory@aqsis.org
  5. //
  6. // This library is free software; you can redistribute it and/or
  7. // modify it under the terms of the GNU General Public
  8. // License as published by the Free Software Foundation; either
  9. // version 2 of the License, or (at your option) any later version.
  10. //
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14. // General Public License for more details.
  15. //
  16. // You should have received a copy of the GNU General Public
  17. // License along with this library; if not, write to the Free Software
  18. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  
  20.  
  21. /** \file
  22.         \brief Declares the CqVector2D class which encapsulates a 2D vector.
  23.         \author Paul C. Gregory (pgregory@aqsis.org)
  24. */
  25.  
  26. //? Is .h included already?
  27. #ifndef VECTOR2D_H_INCLUDED
  28. #define VECTOR2D_H_INCLUDED 1
  29.  
  30. #include    <iostream>
  31.  
  32. #include    <math.h>
  33.  
  34. #include    "aqsis.h"
  35.  
  36. START_NAMESPACE( Aqsis )
  37.  
  38. //-----------------------------------------------------------------------
  39.  
  40. class CqVector3D;
  41. class CqVector4D;
  42.  
  43. //----------------------------------------------------------------------
  44. /** \class CqVector2D
  45.  * \brief Define class structure for 2D vector.
  46.  */
  47.  
  48. class CqVector2D
  49. {
  50.     public:
  51.         CqVector2D() : m_x(0.0f), m_y(0.0f)
  52.         {}
  53.         CqVector2D( TqFloat x, TqFloat y ) : m_x( x ), m_y( y )
  54.         {}
  55.         CqVector2D( const CqVector3D &From );
  56.         CqVector2D( const CqVector4D &From );
  57.         ~CqVector2D()
  58.         {}
  59.  
  60.         /** Get the x component.
  61.          */
  62.         TqFloat    x() const
  63.         {
  64.             return ( m_x );
  65.         }
  66.         /** Set the x component.
  67.          * \param x Float new value.
  68.          */
  69.         void    x( TqFloat x )
  70.         {
  71.             m_x = x;
  72.         }
  73.         /** Get the y component.
  74.          */
  75.         TqFloat    y() const
  76.         {
  77.             return ( m_y );
  78.         }
  79.         /** Set the y component.
  80.          * \param y Float new value.
  81.          */
  82.         void    y( TqFloat y )
  83.         {
  84.             m_y = y;
  85.         }
  86.  
  87.         /** Access the components as an array.
  88.          * \param i Integer component index, 0 or 1.
  89.          * \return Appropriate component or y if invalid index.
  90.          */
  91.         TqFloat&    operator[] ( TqInt i )
  92.         {
  93.             switch ( i )
  94.             {
  95.                 case 0:
  96.                     return ( m_x );
  97.                     break;
  98.                 case 1:
  99.                     return ( m_y );
  100.                     break;
  101.                 default:
  102.                     break;
  103.             }
  104.             return ( m_y );
  105.         }
  106.  
  107.         /** Access the components as an array.
  108.          * \param i Integer component index, 0 or 1.
  109.          * \return Appropriate component or y if invalid index.
  110.          */
  111.         const TqFloat&    operator[] ( TqInt i ) const
  112.         {
  113.             switch ( i )
  114.             {
  115.                 case 0:
  116.                     return ( m_x );
  117.                     break;
  118.                 case 1:
  119.                     return ( m_y );
  120.                     break;
  121.                 default:
  122.                     break;
  123.             }
  124.             return ( m_y );
  125.         }
  126.  
  127.         /** Get the length squared.
  128.          */
  129.         TqFloat    Magnitude2() const
  130.         {
  131.             return ( ( m_x * m_x ) + ( m_y * m_y ) );
  132.         }
  133.         /** Get the length.
  134.          */
  135.         TqFloat    Magnitude() const
  136.         {
  137.             return ( sqrt( ( m_x * m_x ) + ( m_y * m_y ) ) );
  138.         }
  139.         void    Unit()
  140.         {
  141.             TqFloat Mag = Magnitude();
  142.  
  143.             m_x /= Mag;
  144.             m_y /= Mag;
  145.         }
  146.  
  147.         CqVector2D& operator= ( const CqVector3D &From );
  148.         CqVector2D& operator= ( const CqVector4D &From );
  149.         /** Addition assignment operator.
  150.          */
  151.         CqVector2D& operator+=( const CqVector2D &From )
  152.         {
  153.             m_x += From.m_x;
  154.             m_y += From.m_y;
  155.             return ( *this );
  156.         }
  157.         /** Componentwise addition assignment operator.
  158.          */
  159.         CqVector2D& operator+=( const TqFloat &f )
  160.         {
  161.             m_x += f;
  162.             m_y += f;
  163.             return ( *this );
  164.         }
  165.         /** Subtraction assignment operator.
  166.          */
  167.         CqVector2D& operator-=( const CqVector2D &From )
  168.         {
  169.             m_x -= From.m_x;
  170.             m_y -= From.m_y;
  171.             return ( *this );
  172.         }
  173.         /** Componentwise subtraction assignment operator.
  174.          */
  175.         CqVector2D& operator-=( const TqFloat &f )
  176.         {
  177.             m_x -= f;
  178.             m_y -= f;
  179.             return ( *this );
  180.         }
  181.         /** Coponent wise scale operator.
  182.          */
  183.         CqVector2D& operator*=( const TqFloat Scale )
  184.         {
  185.             m_x *= Scale;
  186.             m_y *= Scale;
  187.             return ( *this );
  188.         }
  189.         /** Scale operator.
  190.          */
  191.         CqVector2D& operator*=( const CqVector2D &Scale )
  192.         {
  193.             m_x *= Scale.m_x;
  194.             m_y *= Scale.m_y;
  195.             return ( *this );
  196.         }
  197.         /** Inverse scale operator.
  198.          */
  199.         CqVector2D& operator/=( const CqVector2D &Scale )
  200.         {
  201.             m_x /= Scale.m_x;
  202.             m_y /= Scale.m_y;
  203.             return ( *this );
  204.         }
  205.         /** Component wise inverse scale operator.
  206.          */
  207.         CqVector2D& operator/=( const TqFloat Scale )
  208.         {
  209.             m_x /= Scale;
  210.             m_y /= Scale;
  211.             return ( *this );
  212.         }
  213.         /** Equality operator.
  214.          */
  215.         TqBool    operator==( const CqVector2D &Cmp ) const
  216.         {
  217.             return ( ( m_x == Cmp.m_x ) && ( m_y == Cmp.m_y ) );
  218.         }
  219.         /** Inequality operator.
  220.          */
  221.         TqBool    operator!=( const CqVector2D &Cmp ) const
  222.         {
  223.             return ( ( m_x != Cmp.m_x ) || ( m_y != Cmp.m_y ) );
  224.         }
  225.  
  226.         friend CqVector2D    operator+( const TqFloat f, const CqVector2D& v )
  227.         {
  228.             return CqVector2D( f + v.x(), f + v.y() );
  229.         }
  230.         friend CqVector2D    operator+( const CqVector2D& v, const TqFloat f )
  231.         {
  232.             CqVector2D r( v );
  233.             return ( r += f );
  234.         }
  235.         friend CqVector2D    operator-( const TqFloat f, const CqVector2D& v )
  236.         {
  237.             return CqVector2D( f -v.x(), f - v.y() );
  238.         }
  239.         friend CqVector2D    operator-( const CqVector2D& v, const TqFloat f )
  240.         {
  241.             CqVector2D r( v );
  242.             return ( r -= f );
  243.         }
  244.         friend CqVector2D    operator*( const TqFloat f, const CqVector2D& v )
  245.         {
  246.             return CqVector2D( f * v.x(), f * v.y() );
  247.         }
  248.         friend CqVector2D    operator*( const CqVector2D& v, const TqFloat f )
  249.         {
  250.             CqVector2D r( v );
  251.             return ( r *= f );
  252.         }
  253.         friend CqVector2D    operator/( const TqFloat f, const CqVector2D& v )
  254.         {
  255.             return CqVector2D( f / v.x(), f / v.y() );
  256.         }
  257.         friend CqVector2D    operator/( const CqVector2D& v, const TqFloat f )
  258.         {
  259.             CqVector2D r( v );
  260.             return ( r /= f );
  261.         }
  262.  
  263.         friend CqVector2D    operator+( const CqVector2D& a, const CqVector2D& b )
  264.         {
  265.             CqVector2D r( a );
  266.             return ( r += b );
  267.         }
  268.         friend CqVector2D    operator-( const CqVector2D& a, const CqVector2D& b )
  269.         {
  270.             CqVector2D r( a );
  271.             return ( r -= b );
  272.         }
  273.         friend CqVector2D    operator/( const CqVector2D& a, const CqVector2D& b )
  274.         {
  275.             CqVector2D r( a );
  276.             return ( r /= b );
  277.         }
  278.         friend CqVector2D    operator-( const CqVector2D& v )
  279.         {
  280.             return ( CqVector2D( -v.m_x, -v.m_y ) );
  281.         } // Negation
  282.  
  283.         friend TqFloat    operator*( const CqVector2D& a, const CqVector2D& b )
  284.         {
  285.             return ( a.m_x * b.m_x + a.m_y * b.m_y );
  286.         } // Dot product
  287.         friend std::ostream &operator<<( std::ostream &Stream, const CqVector2D &Vector );
  288.  
  289.     protected:
  290.         TqFloat    m_x;        ///< X component.
  291.         TqFloat    m_y;        ///< Y component.
  292. }
  293. ;
  294.  
  295. //-----------------------------------------------------------------------
  296.  
  297. END_NAMESPACE( Aqsis )
  298.  
  299. #endif    // !VECTOR2D_H_INCLUDED
  300.